dev-suite/src/tools/code_parser.py (3)

61-65: Consider adding explicit rejection of Windows-style absolute paths.

The current check only catches Unix absolute paths (/etc/passwd). Windows paths like C:\secret.txt become C:/secret.txt after normalization and pass this check. While validate_paths_for_workspace would catch this downstream, rejecting it here provides clearer error messages and earlier failure.

🔧 Optional enhancement

     # Reject absolute paths
     if cleaned.startswith("/"):
         raise CodeParserError(
             f"Absolute path not allowed: '{raw_path}'"
         )
+
+    # Reject Windows-style absolute paths (e.g., C:/ or D:\)
+    if len(cleaned) >= 2 and cleaned[1] == ":" and cleaned[0].isalpha():
+        raise CodeParserError(
+            f"Absolute path not allowed: '{raw_path}'"
+        )

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@dev-suite/src/tools/code_parser.py` around lines 61 - 65, The current
rejection only checks Unix-style absolute paths via cleaned.startswith("/") so
add an explicit Windows absolute-path check (drive letter followed by :/ or :\)
and raise CodeParserError with a clear message using raw_path; e.g., detect with
a regex like r'^[A-Za-z]:[\\/]' against cleaned (or raw_path) and raise the same
CodeParserError to fail early (this complements validate_paths_for_workspace).
Update the block that references cleaned and raw_path to include this additional
condition and error.

---

186-193: Move logging import to module level.

The import logging inside the function is unconventional. Since logging is a standard library module with no circular import risk, it should be imported at the top of the file alongside other imports.

♻️ Move import to module level

At the top of the file (around line 14):

import logging

Then remove lines 187-188 from inside the function.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@dev-suite/src/tools/code_parser.py` around lines 186 - 193, The inline
"import logging" inside the function should be moved to the module level; add
"import logging" with the other imports at top of the file and remove the
in-function import lines so the existing
logging.getLogger(__name__).warning(...) call (which logs "Skipping file with
path escaping workspace: %s -> %s" and references pf.path and target) continues
to work without a local import.

---

145-156: Minor inefficiency: paths are normalized twice.

Each path is normalized once at line 123 (stored in seen) and again at lines 150 when building ordered_paths. Since the normalized paths are already stored as keys in seen, you could simplify by tracking insertion order directly.

♻️ Optional simplification using ordered dict semantics

Since Python 3.7+ dicts maintain insertion order, you could track first-seen order directly:

     # Extract files between markers
-    seen: dict[str, ParsedFile] = {}
+    seen: dict[str, ParsedFile] = {}  # Maintains insertion order (Python 3.7+)
+    first_seen_order: list[str] = []

     for i, match in enumerate(markers):
         raw_path = match.group(1)
         path = _normalize_path(raw_path)

+        if path not in seen:
+            first_seen_order.append(path)
+
         # Content starts after this marker's line
         # ...

         # Last occurrence wins for duplicate paths
         seen[path] = ParsedFile(path=path, content=content)

-    # Return in order of first appearance, but with last-wins content
-    ordered_paths: list[str] = []
-    for match in markers:
-        raw_path = match.group(1)
-        try:
-            path = _normalize_path(raw_path)
-        except CodeParserError:
-            continue
-        if path not in ordered_paths:
-            ordered_paths.append(path)
-
-    return [seen[p] for p in ordered_paths if p in seen]
+    return [seen[p] for p in first_seen_order]

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@dev-suite/src/tools/code_parser.py` around lines 145 - 156, The code
currently normalizes paths twice: once when populating seen and again when
building ordered_paths; instead, track first-seen order when you populate seen
so you can return in first-appearance order without re-normalizing. Update the
code that assigns into seen (the block that calls _normalize_path and sets
seen[path]=...) to also append path to an ordered_paths list when the key is
first added, remove the second normalization loop that iterates markers and
calls _normalize_path again, and change the final return to use the
ordered_paths list and seen (i.e., return [seen[p] for p in ordered_paths if p
in seen]); reference variables/functions: seen, markers, _normalize_path,
ordered_paths.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes